home *** CD-ROM | disk | FTP | other *** search
/ SGI Varsity Update 1998 August / SGI Varsity Update 1998 August.iso / dist / patchSG0002777.idb / usr / include / sys / proc.h.z / proc.h
C/C++ Source or Header  |  1998-07-29  |  36KB  |  919 lines
  1. /**************************************************************************
  2.  *                                      *
  3.  *          Copyright (C) 1989-1993 Silicon Graphics, Inc.          *
  4.  *                                      *
  5.  *  These coded instructions, statements, and computer programs  contain  *
  6.  *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
  7.  *  are protected by Federal copyright law.  They  may  not be disclosed  *
  8.  *  to  third  parties  or copied or duplicated in any form, in whole or  *
  9.  *  in part, without the prior written consent of Silicon Graphics, Inc.  *
  10.  *                                      *
  11.  **************************************************************************/
  12. /*    Copyright (c) 1984 AT&T    */
  13. /*      All Rights Reserved      */
  14.  
  15. /*    THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T    */
  16. /*    The copyright notice above does not evidence any       */
  17. /*    actual or intended publication of such source code.    */
  18. #ifndef __SYS_PROC_H__
  19. #define __SYS_PROC_H__
  20.  
  21. #ident    "$Revision: 3.282 $"
  22.  
  23. /*    One structure allocated per active process. It contains all
  24. **    data needed about the process while the process may be swapped
  25. **    out.  Other per process data (user.h) may swapped with the
  26. **    process.
  27. */
  28.  
  29. #include <sys/types.h>
  30.  
  31. #ifdef USE_LGPAGES
  32. #include <sys/pfdat.h>
  33. #endif
  34.  
  35. #ifdef _VM_WS_SWAPPING
  36. /*
  37.  * Working set swapping information structure, for proc and shaddr
  38.  * structures.
  39.  *
  40.  * Most fields are protected only by atomic update operations.
  41.  */
  42.  
  43. typedef struct ws_proc_s {
  44.     /*
  45.      * Virtual Memory Working Set Swapping 
  46.      */
  47.     time_t    ws_slice_limit;        /* working set slice time     */
  48.                     /* limit (future lbolt value)    */
  49.     time_t    ws_active_time;     /* last time process was    */
  50.                     /* runnable            */
  51.     pri_t    ws_pri;            /* working set priority     */
  52.     pri_t    ws_upri;        /* working set priority     */
  53.     int    ws_flags;        /* working set state flags    */
  54.  
  55. #define P_WSF_HAS_SWAPPED_PAGES 0x0001    /* one or more pages in pmap     */
  56.                     /* with WS_SENTRY in pg_pfn    */
  57. #define P_WSF_SWAPPING_IN       0x0002    /* in ws_swapin_process()    */
  58. #define P_WSF_SWAPPING_OUT    0x0004    /* in ws_swapout_process()    */
  59. #define P_WSF_CLEAR_SLOAD       0x0008    /* clear SLOAD when possible    */
  60. #define P_WSF_CLEAR_SLOAD_READY 0x0010    /* ready for SLOAD to be cleared */
  61. #define P_WSF_SET_SLOAD        0x0020    /* SLOAD set after begin cleared */
  62.  
  63. } ws_proc_t;
  64. #endif /* _VM_WS_SWAPPING */
  65.  
  66. /*
  67.  * Proc structure and maintenance variables description.
  68.  *
  69.  * The fields in a proc entry are protected by an interwoven set of
  70.  * locks and semaphores.  Separate locks and semaphores are used to
  71.  * squeeze decent performance out of proc table and entry handling.
  72.  * The locks and semaphores, and what they protect, are:
  73.  *
  74.  * The following locks are used solely within a single proc entry,
  75.  * and are thus contained within that entry:
  76.  *
  77.  * SIGLCK -   This bit in p_flag lock is held during signal handling.  It
  78.  *          protects the fields p_sig, p_sigmask, p_phold, and p_nexit.
  79.  *          The lock must be held before examining or modifying any of
  80.  *          these variables at all times.  This lock also is used to
  81.  *          protect the p_stat, p_flag and p_flag2 fields where
  82.  *          protection is necessary.  Protects p_sonproc field which
  83.  *          marks which processors the given proc entry has threads
  84.  *          running on.  Also synchronizes updates to p_cred pointer so
  85.  *          that other processes trying to look at our uid's (to check
  86.  *          permissions to send signals and such) don't get a stale cred
  87.  *          pointer while we're changing cred structs.
  88.  *
  89.  * p_sema   - This semaphore protects the parent-child-sibling chain
  90.  *          rooted at the current proc entry.
  91.  *          Therefore in order to access one's parent, the parent p_sema
  92.  *          must be obtained - though while doing so the parent may have
  93.  *          exitted.
  94.  *
  95.  *          It is important
  96.  *          to realize that some fields in the proc structure can only
  97.  *          be modified by the process itself, and thus there is no
  98.  *            protection needed, and the semaphore should not be acquired.
  99.  *
  100.  * p_parlck - This (spinning) mutex protects the p_parent field in the
  101.  *          current proc entry.
  102.  *
  103.  * p_wait   - This semaphore is used exclusively for the wait(2) system call
  104.  *
  105.  * p_aspacelock -
  106.  *          Grab the lock for MR_UPDATE, if the operation will change:
  107.  *        1) pregion list
  108.  *        2) regva, pgoff, pgsz, r_list
  109.  *          Otherwise grab it MR_ACCESS if accessing any translations
  110.  *
  111.  * Links:
  112.  *          Free proc structures are threaded on p_link (== p_flink)
  113.  *          Runnable procs are double threaded on p_flink & p_blink
  114.  *          Sleeping procs are double threaded on p_flink & p_blink
  115.  *          Active procs are threaded on p_active
  116.  *          Exiting procs are threaded on p_link
  117.  *
  118.  * The following locks are used in global proc table management:
  119.  *
  120.  * pfreelck - This lock protects the free process list.  This is a list
  121.  *            of all free process slots, to avoid an unnecessary search
  122.  *          when creating a new process.  The free process list is
  123.  *          strung through the p_active field of the proc structure.
  124.  *
  125.  * pactlck  - This lock protects the active process list.  This is a list
  126.  *          of all active processes, and is primarly used when creating
  127.  *          a new process to reduce the search time for a new PID.  It
  128.  *          is strung through the p_active field of the proc structure.
  129.  *
  130.  * nextpidlock -
  131.  *          This lock protects the variables nextpid, nextinuse, and
  132.  *          pidinuse which are used to generate the next valid PID.
  133.  */
  134.  
  135. #include <sys/param.h>
  136. #include <sys/sema.h>
  137. #include <sys/time.h>
  138. #include <sys/timers.h>
  139. #include <sys/immu.h>
  140. #include <sys/ufchunk.h>
  141. #include <sys/poll.h>
  142.  
  143. #if defined(_KERNEL) || defined(_KMEMUSER)
  144.  
  145. #include <sys/region.h>
  146. #include <sys/kabi.h>
  147. #include <sys/ptimers.h>
  148.  
  149. struct session;        /* look in session.h for real definition */
  150.  
  151. #include <sys/kthread.h>
  152.  
  153. #define p_flink        p_kthread.k_flink
  154. #define p_blink        p_kthread.k_blink
  155. #define p_flag        p_kthread.k_flag
  156. #define p_flag2        p_kthread.k_flag2
  157. #define p_wchan        p_kthread.k_wchan
  158. #define p_w2chan    p_kthread.k_w2chan
  159. #define p_pid        p_kthread.k_pid
  160. #define p_stime        p_kthread.k_stime
  161. #define p_stat        p_kthread.k_stat
  162.  
  163. #define p_pri        p_kthread.k_pri
  164. #define p_upri        p_kthread.k_upri
  165. #define p_saveupri    p_kthread.k_saveupri
  166. #define p_mblock    p_kthread.k_mblock
  167. #define p_pilist    p_kthread.k_pilist
  168. #define p_pilck        p_kthread.k_pilck
  169. #define p_sonproc    p_kthread.k_sonproc
  170. #define p_mustrun    p_kthread.k_mustrun
  171. #define p_onrq        p_kthread.k_onrq
  172. #define p_lastrun    p_kthread.k_lastrun
  173. #define p_sqself    p_kthread.k_sqself
  174. #define p_rtpri        p_kthread.k_rtpri
  175. #define p_tslice    p_kthread.k_tslice
  176. #define p_dvec        p_kthread.k_dvec
  177. #define p_runqinfo    p_kthread.k_runqinfo
  178. #define p_start        p_kthread.k_start
  179.  
  180. typedef struct    proc {
  181.     kthread_t    p_kthread;    /* kernel thread common fields */
  182.     char        p_cpu;        /* cpu usage for scheduling */
  183.     char        p_nice;        /* nice for cpu usage */
  184.     char        p_time;        /* resident time for scheduling */
  185.     char        p_hasprda;    /* proc has touched its prda page */
  186.     gid_t        p_pgrp;        /* name of process group leader */
  187.     pid_t        p_ppid;        /* process id of parent*/
  188.     lock_t        p_parlck;    /* lock to protect p_parent */
  189.     struct proc    *p_parent;    /* ptr to parent process */
  190.     struct proc    *p_child;    /* ptr to first child process */
  191.     struct proc    *p_sibling;    /* ptr to next sibling proc on chain */
  192.     struct proc    *p_active;    /* active process chain        */
  193.  
  194.     pgno_t        p_size;        /* size of swappable image in pages */
  195.     pgno_t        p_rss;        /* resident size of swappable image  */
  196.                     /* in pages.            */
  197.     pgno_t        p_maxrss;    /* max rss - from u_limit    */
  198.     unsigned char    *p_tlbpid;    /* pointer to tlbpid array    */
  199.     unsigned char    *p_icachepid;    /* pointer to tlbpid array    */
  200.     /*
  201.      * The following 2 fields are extended if EXTUSIZE == 1 to
  202.      * accomodate kernel stack extension page.
  203.      */
  204.     pde_t        p_upgs[USIZE+EXTUSIZE];    /* pdes for upage/user kstk */
  205.     sm_swaphandle_t p_uswap[USIZE+EXTUSIZE]; /* swap handles for upage/ustk    */
  206.     unsigned short    p_resident;    /* process cannot be swapped    */
  207.     unsigned short    p_reglockindx;    /* pregion lock index */
  208.     preg_set_t    p_region;    /* process regions        */
  209.     pgno_t        p_totpregsize;    /* total size of regions.     */
  210.     struct pregion    *p_tsave;    /* list of 'saved' text pregions */
  211.     pgno_t        p_nlockpg;    /* # locked pages        */
  212.     pid_t        p_epid;        /* effective pid; normally same as
  213.                      * p_pid; for servers, the system that
  214.                      * sent the msg */
  215.     sysid_t        p_sysid;    /* normally - same as sysid */
  216.                     /* if server - system that sent msg */
  217.  
  218.     int    p_dismissed_exc_cnt;    /* how many speculative instructions */
  219.                     /* have caused exceptions? */
  220.     char        p_vmsched;    /* sched info from VM system    */
  221.     char        p_prtn;        /* semaphore return value    */
  222.     short        p_nexit;    /* delay exit */
  223.     struct proc    *p_nexit_waiter;/* process (parent) waiting on ZOMB */
  224.  
  225.     k_sigset_t    p_sigmask;    /* tracing signal mask for /proc */
  226.     k_sigset_t    *p_phold;    /* pointer to hold signal bit mask */
  227.     k_sigset_t    p_khold;    /* p_phold points here or to prda */
  228.     k_sigset_t    p_sig;        /* signals pending to this    */
  229.                     /* process            */
  230.     k_sigset_t    p_sigwait;    /* set of signals we are waiting on */
  231.     struct sigvec_s *p_sigvec;    /* pointer to signal vector info */
  232.  
  233.     mutex_t        p_sema;        /* semaphore on entry        */
  234.     sv_t        p_wait;        /* waiting for something to happen */
  235.     ushort        p_whystop;    /* Reason for process stop */
  236.     ushort        p_whatstop;    /* More detailed reason */
  237.     time_t        p_utime;    /* user time in ticks */
  238.     ushort        p_pollrotor;    /* wakeup rotor for poll() */
  239.     short        p_xstat;    /* exit status for wait */ 
  240.     struct rusage    *p_ru;
  241.     struct itimer_info {
  242.         struct    itimerval realtimer; /* time to next real alarm */
  243.         lock_t    itimerlock;    /* ITIMER_REAL handling lock */
  244.         __uint64_t interval_tick;
  245.         __uint64_t next_timeout;
  246.         int    interval_unit;
  247.  
  248.         /*
  249.          * We put p_pollrotorlock here because it's otherwise 4 bytes
  250.          * of padding in both 32- and 64-bit kernels.  This allows us
  251.          * to avoid changing the size/layout of the proc structure.
  252.          */
  253.         lock_t    pollrotorlock;    /* lock for pollrotor */
  254.     } p_ii;
  255.     struct ssleep_s    *p_block;    /* block struct for blockproc() */
  256.     struct proc    *p_slink;    /* share group link */
  257.     struct shaddr_s    *p_shaddr;    /* pointer to shared group desc */
  258.     uint        p_shmask;    /* share group share mask */
  259.     char        p_exitsig;    /* signal to send on exit of sharegrp */
  260.     char        p_fp;        /* generate SIGFPE on fp interrupts */
  261.     u_char        p_abi;        /* what abi are we running? */
  262.     char        p_fpflags;    /* fp emulation flags */
  263.     struct syscallsw *p_syscall;    /* pointer to syscall handler info */
  264.     int        p_cpfaultcnt;    /* count the number of cop1 faults */
  265.     struct prda    *p_prda;    /* K0 addr of locked-down prda */
  266.  
  267.     struct pmap    *p_pmap;    /* page map pointer */
  268.     pde_t        **p_segtbl;    /* primary segment table pointer */
  269.     pde_t        **p_shrdsegtbl;    /* overlap segment table pointer */
  270. #ifndef _K64U64
  271.     pde_t        **p_segtbl_wired;    /* wired VA for p_segtbl */
  272.     pde_t        **p_shrdsegtbl_wired;    /* wired VA for p_shrdsegtbl */
  273. #endif /* !K64U64 */
  274.     ushort        p_segflags;    /* segment table flags */
  275.     ushort        p_jwhatstop;    /* job control stop signal */
  276.     mrlock_t    p_alock;    /* non shared group aspace lock */
  277.     mrlock_t    *p_aspacelock;    /* address space lock */
  278.     struct pwatch_s    *p_watch;    /* watchpoint list */
  279.     struct proc     *p_pgflink;    /* process group chain */
  280.     struct proc     *p_pgblink;    /* process group chain */
  281.     struct pgroup_s *p_pgroup;    /* process group structure */
  282.     struct pollhead    p_poll;        /* process select/polling via /proc */
  283.     struct session    *p_session;    /* session */
  284.     struct uidinfo_s *p_uidinfo;    /* count of procs with this uid, ... */
  285.     struct cred    *p_cred;    /* process credentials        */
  286.     int        p_wdata;    /* current wait return value */
  287.     int        p_wcode;    /* current wait code, 1 byte only */
  288.     caddr_t        p_brkbase;    /* base addr of heap for brk/sbrk */
  289.     size_t        p_brksize;    /* size of heap */
  290.     caddr_t        p_stkbase;    /* base addr of stack (lowest adddr) */
  291.     size_t        p_stksize;    /* size of stack */
  292.     struct user     *p_user;    /* K2SEG address for u area */
  293.     struct sigqueue *p_curinfo;     /* siginfo for current signal */
  294.     sv_t        p_sigpollwait;    /* waiting in sigpoll() */
  295.     int        p_utlbmissswtch;/* utlbmiss handler index */
  296.     volatile u_long p_procref;    /* #of driver refs to proc */
  297.     struct sat_ev_mask *p_satmask;    /* process-local audit event mask */
  298.     struct vnode    *p_trace;    /* pointer to /proc vnode */
  299.     struct vnode    *p_pstrace;    /* pointer to /proc/pinfo vnode */
  300.     int             p_proctimer;    /* index in to array below  */
  301.     unsigned    p_secsnap;    /* sec snap shot for sleep timers */
  302. #define u_ptimer    u_procp->p_timertab
  303.     ktimer_t        p_timertab[MAX_PROCTIMER]; /*accounting states timers */
  304.     ktimer_t        p_ctimertab[MAX_PROCTIMER]; /*  "          "     '' */
  305.     struct vnode    *p_exec;    /* vnode for original exec */
  306.     time_t        p_slptime;    /* lbolt when going to SSLEEP|SSTOP */
  307.     time_t        p_pmaptrimtime;    /* timestamp for pmap trimming */
  308.     struct arsess    *p_arsess;    /* array session info */
  309.  
  310. #ifdef _VM_WS_SWAPPING
  311.     ws_proc_t    p_ws;        /* working set swapping variables */
  312. #endif /* _VM_WS_SWAPPING */
  313. #ifdef    _SHAREII
  314.     struct ShadProc_t *p_shareP;    /* pointer to shadow proc entry */
  315. #endif    /* _SHAREII */
  316.     lock_t        p_kobjlock;    /* protect p_kobj lists */
  317.     kobj_t        *p_kobj[MAX_MODULES];
  318. #ifdef ULI
  319.     struct uli    *p_uli;        /* chain of ULIs for this proc */
  320. #endif
  321. #ifdef    _HIBERNATORII
  322.     lock_t        p_hib_lock;    /* Hibernator lock - do we need it? */
  323.     ushort        fill1;
  324.     struct bias    *p_hib_bias;    /* Hibernator accounting bias */
  325.     int        p_hib_set;    /* Hibernator checkpoint-set id */
  326.     int        p_hib_flags;    /* Hibernator checkpoint flags */
  327.     int        p_hib_spare[3]; /* future use */
  328. #endif    /* _HIBERNATORII */
  329.  
  330. #ifdef USE_LGPAGES
  331.     spec_pglist_t   *p_spages;      /* special pages to wire into tlb */
  332. #endif
  333.     struct exit_callback *p_ecblist; /* funcs to call on exit */
  334.     ptimer_info_t    *p_ptimers;    /* array of posix timers */
  335. #ifdef SWASH
  336.     caddr_t        p_swash_ptes;    /* SWASH page tables */
  337.     caddr_t        p_swash_hndlr;  /* SWASH callback */
  338.     caddr_t        p_swash_state;  /* SWASH callback arg */
  339. #endif
  340.         __psint_t    p_ppolicy;    /* posix scheduling policy */
  341. } proc_t;
  342.  
  343. typedef union thread {
  344.     kthread_t    kthread;
  345.     proc_t        proc;
  346. } thread_t;
  347.  
  348. #define    IS_KTHREAD(t)        (((thread_t *)t)->kthread.k_flag2 & SKTHREAD)
  349.  
  350. #define p_siglock(p)        mutex_bitlock(&(p)->p_flag, SIGLCK)
  351. #define p_siglock_spl(p,f)    mutex_bitlock_spl(&(p)->p_flag, SIGLCK,f)
  352. #define p_sigunlock(p,rv)    mutex_bitunlock(&(p)->p_flag, SIGLCK, rv)
  353. #define p_flagset(p,b)        bitlock_set(&(p)->p_flag, SIGLCK, b)
  354. #define p_flagclr(p,b)        bitlock_clr(&(p)->p_flag, SIGLCK, b)
  355. #define p_sleep(p,s,f,rv)    sv_bitlock_wait(s, f, &(p)->p_flag, SIGLCK, rv)
  356. #define p_sleepsig(p,s,f,rv) \
  357.             sv_bitlock_wait_sig(s, f, &(p)->p_flag, SIGLCK, rv)
  358. #define p_issiglocked(p)     bitlock_islocked(&(p)->p_flag, SIGLCK)
  359. #define p_bitlock        p_flag
  360.  
  361. /* The nested-lock routines are for use only
  362.  * by locking primitives and scheduler!
  363.  */
  364. #define p_nested_siglock(p)    nested_bitlock(&(p)->p_flag, SIGLCK)
  365. #define p_nested_sigunlock(p)    nested_bitunlock(&(p)->p_flag, SIGLCK)
  366.  
  367.  
  368. #define origpri(p) ((p)->p_rtpri ? (p)->p_rtpri : (p)->p_saveupri)
  369.  
  370. #define proc_to_user(p) ((p)->p_user)
  371.  
  372. #define    p_link        p_flink
  373. #define p_minwd        ps.rs.minwd
  374. #define p_rlink        ps.rs.rlink
  375. #define p_realtimer    p_ii.realtimer
  376. #define p_itimerlock    p_ii.itimerlock
  377. #define p_itimer_tick    p_ii.interval_tick
  378. #define p_itimer_unit    p_ii.interval_unit
  379. #define p_itimer_next    p_ii.next_timeout
  380. #define p_pollrotorlock    p_ii.pollrotorlock
  381.  
  382. #ifdef _K64U64
  383. /* In 64-bit kernels all memory is directly addressable, so there's no need
  384.  * to maintain a separate entry for the wired address of the segtbl(s).
  385.  */
  386. #define    p_segtbl_wired        p_segtbl
  387. #define    p_shrdsegtbl_wired    p_shrdsegtbl
  388. #endif /* _K64U64 */
  389.  
  390. #ifndef _IRIX_LATER
  391. /* The following macros are here to ease the transition to cred's so
  392.  * we don't have to rewrite all the existing code.  Their values can
  393.  * be read at any time, but stores into them should be done with care
  394.  * since cred structs are shared among processes.
  395.  */
  396. #include <sys/cred.h>
  397. #define p_uid        p_cred->cr_ruid
  398. #define p_suid        p_cred->cr_suid
  399. #define p_sgid        p_cred->cr_sgid
  400. #define p_mac        p_cred->cr_mac
  401. #define p_inf        p_cred->cr_inf
  402. #define p_cap        p_cred->cr_cap
  403. #endif
  404.  
  405. /* p_itimerunit */
  406. #define FAST_TICK    1
  407. #define SLOW_TICK    0
  408.  
  409. /* p_segflags - a bitmask to enable fast tests */
  410. #define PSEG_SEG    0x1    /* use segment table */
  411. #define PSEG_TRILEVEL    0x2    /* use tri-level segment table */
  412.  
  413. /* cpu isn't on (wasn't on) any processor */
  414. #define CPU_NONE (cpuid_t)-1
  415.  
  416. /* flag codes */
  417.  
  418. #define    SSYS    0x00000001    /* System (resident) process.    */
  419. #define    STRC    0x00000002    /* Process is being traced.    */
  420. #define    SBIT0    0x00000004    /* reserved for atomic-bit0 */
  421. #define SNWAKE    0x00000008    /* Process cannot wakeup by a signal.*/
  422. #define SLOAD    0x00000010    /* In core                      */
  423. #define SULOAD    0x00000020    /* ublock in core        */
  424. #define    SATMSIM    0x00000040    /* Look for atomic operation simulation */
  425. #define    SIGLCK    0x00000080    /* Lock bit for flags, etc. */
  426. #define SPRSTOP    0x00000100    /* process is being stopped via /proc */
  427. #define SPROCTR    0x00000200    /* sysent/exit/fault/signal tracing via /proc */
  428. #define    SPARSYS    0x00000400    /* tracing sys calls via par */
  429. #define SEXECING 0x0000800    /* process is execing */
  430. #define SPROPEN    0x00001000    /* process is open via /proc    */
  431. #define SUWANT    0x00002000    /* want ublock in core        */
  432. #define    SNOCTTY    0x00004000    /* no control terminal */
  433. #define    SOWEUPC    0x00008000    /* owe user an addupc call (profiling tick) */
  434. #define SWSYS    0x00010000    /* process got watchpoint in system */
  435. #define SSHBSYN    0x00020000    /* process needs to sync brkbase/size */
  436. #define SEXIT    0x00040000    /* process is exiting        */
  437. #define SBSDSTOP 0x00080000    /* proces did BSDsetpgrp so send CLD */
  438. #define SWSRCH    0x00100000    /* process is scanning in wait */
  439. #define SSHDSYN 0x00200000    /* process needs to sync current dir */
  440. #define SSHUSYN 0x00400000    /* process needs to sync uids    */
  441. #define SSHLSYN 0x00800000    /* process needs to sync ulimit    */
  442. #define SSHMSYN 0x01000000    /* process needs to sync umask    */
  443. #define SBLOCK    0x02000000    /* process may need to block itself */
  444. #define SPROF    0x04000000    /* process is profiling */
  445. #define SSTEP    0x08000000    /* process is single stepping */
  446. #define SNOSIG    0x10000000    /* process can't receive any signals */
  447. #define SABORTSIG 0x20000000    /* signal on abort */
  448. #define SRECALC 0x40000000    /* short term or long term wait */
  449. #define SGRAPH  0x80000000    /* member of share group just given graphics */
  450.  
  451. #define PTRACED(p)    ((p)->p_flag&(STRC|SPROCTR|SPROPEN))
  452. #define PSYNCFLAGS    (SSHDSYN|SSHUSYN|SSHLSYN|SSHMSYN|SSHBSYN)
  453.  
  454. /* values for p_flag2 */
  455. #define SNOSWAP        0x00000001    /* communicate no swap condition vhand->proc */
  456. #define SCEXIT        0x00000002    /* this process will die when parent exits */
  457. #define SBBLST        0x00000004    /* its been blasted by sched deadlock scan */
  458. #define SPRPIOPEN   0x00000008    /* process is open via /proc/pinfo */
  459. #define SEXECED        0x00000010    /* process successfully exec'ed (for setpgid) */
  460. #define    SFIXADE        0x00000020    /* fixup unaligned address errors */
  461. #define SPARTRC     0x00000040    /* par is tracing this */
  462. #define SWAITCHAN   0x00000080    /* hold wchan */
  463. #define SONCESTOPPED 0x0000100    /* won't run in user space again */
  464. #define SWRTLOCK    0x00000200  /* p_wchan object is rtlock */
  465. #define SWMUTEX        0x00000400    /* p_wchan object is mutex */
  466. #define SWSV        0x00000800    /* p_wchan object is sync variable */
  467. #define SLONGJMPOK  0x00001000    /* longjmp permitted during current syscall */
  468. #define SMPCWAROFF  0x00002000    /* turn off libmpc WAR */
  469. #define SPIPE        0x00004000    /* turn on stream pipe */
  470. #define SISOLATE    0x00008000    /* process is mustrun on an isolated cpu */
  471. #define SPROF32        0x00010000    /* profiling process uses 32-bit buckets */
  472. #define SOPENPOST   0x00020000    /* process opened Oracle postwait driver */
  473. #define SMUSTRUNLCK 0x00040000    /* process locked to mustrun cpu */
  474. #define SPROFFAST   0x00100000    /* profiling process 10 times per tick */
  475. #define SUSERVME    0x00200000    /* process has/had VME space mapped */
  476. #define SNOMRUNINH  0x00400000    /* children shouldn't inherit mustrun */
  477. #define SCOREPID    0x00800000    /* when dumping core, add pid */
  478. #define    SPRELOADFP  0x01000000    /* preload FP on process switch */
  479. #define SJSTOP        0x02000000    /* process wants to job control stop */
  480. #define    SWTED        0x04000000    /* Stopped process has been given */
  481.                 /* to parent by wait system call. */
  482.                 /* Don't return this process to parent */
  483.                 /* again until it runs first.    */
  484. #define    STLBMISS    0x10000000    /* running with non-standard UTLBMISS handler */
  485. #define SKTHREAD    0x20000000    /* Thread has no user struct */
  486. #define    SASYNCIO    0x80000000    /* Using kernel async i/o */
  487.  
  488. #ifdef    _HIBERNATORII
  489. /* Hibernator internal flags (p_hib_flags) */
  490. #define PRGRPOPEN    0x00000001    /* open in group */
  491. #define PRGRPWAIT    0x00000002    /* event waited for */
  492. #define PREXIT        0x00000004    /* exit requested via /proc */
  493.  
  494. #define PRISBLOCKED    0x00000010    /* process is blocked */
  495. #define PRSYSENTRY    0x00000020    /* process is blocked at syscall entry */
  496. #endif    /* _HIBERNATORII */
  497.  
  498. /*
  499.  * The defines for p_abi has been moved to kabi.  This is to allow
  500.  * kernel modules which do not include proc.h but include xlate.h,
  501.  * which needs these defines, to compile.
  502.  */
  503.  
  504. #if (_MIPS_SZPTR == 32)
  505. #define    ABI_ICODE    ABI_IRIX5    /* ABI for icode init */
  506. #else
  507. #define    ABI_ICODE    ABI_IRIX5_64    /* ABI for icode init */
  508. #endif
  509.  
  510. /*
  511.  * These two are temporary. They will be established by lboot in the future
  512.  */
  513. #define    _MIN_ABI    ABI_IRIX5    /* lower bound of syscallsw[] */
  514. #define    _MAX_ABI    ABI_IRIX5_N32    /* upper bound of syscallsw[] */
  515.  
  516. /* flags for p_fp */
  517. #define    P_FP_SIGINTR1    1
  518. #define    P_FP_SIGINTR2    2
  519.  
  520. /* Flags for newproc() */
  521. #define NP_FAILOK    0x1    /* don't panic if cannot create process */
  522. #define NP_NOLAST    0x2    /* don't use last process slot */
  523. #define    NP_SYSPROC    0x4    /* system (resident) process */
  524. #endif /* _KERNEL || _KMEMUSER */
  525.  
  526. /* stat codes */
  527. #define    SSLEEP    1        /* Awaiting an event.        */
  528. #define    SRUN    2        /* Running.            */
  529. #define    SZOMB    3        /* Process terminated but not    */
  530.                 /* waited for.            */
  531. #define    SSTOP    4        /* Process stopped by signal    */
  532.                 /* since it is being traced by    */
  533.                 /* its parent.            */
  534. #define    SIDL    5        /* Intermediate state in    */
  535.                 /* process creation.        */
  536. #define SXBRK    7        /* process being xswapped       */
  537.  
  538. /* Reasons for stopping (values of p_whystop) */
  539. #define    REQUESTED    1
  540. #define    SIGNALLED    2
  541. #define    SYSENTRY    3
  542. #define    SYSEXIT        4
  543. #define FAULTED        5
  544. #define JOBCONTROL    6
  545.  
  546. /* Reasons for stopping (p_whatstop) */
  547. #define FAULTEDWATCH    1    /* whystop == FAULTED */
  548. #define FAULTEDKWATCH    2    /* whystop == FAULTED */
  549. #define FAULTEDPAGEIN    3    /* whystop == FAULTED */
  550. #define FAULTEDSTACK    4    /* whystop == FAULTED */
  551. #define FAULTEDSCWATCH    5    /* whystop == FAULTED */
  552.  
  553. /* flags for p_fpflags */
  554. #define    P_FP_IMPRECISE_EXCP    0x01    /* TFP imprecise expeptions */
  555. #define    P_FP_PRESERVE        0x02    /* Preserve p_fpflags across exec */
  556. #define    P_FP_FR            0x04    /* SR_FR bit is set for this process */
  557. #define    P_FP_SMM        0x08    /* FPU is in Sequential Memory Mode */
  558. #define    P_FP_SMM_HDR        0x10    /* SMM specified in elf header */
  559. #define    P_FP_PRECISE_EXCP_HDR    0x20    /* prec exc specified in elf header */
  560. #define P_FP_SPECULATIVE    0x40    /* process executing speculatively */
  561. #define P_FP_OLD_SOFTFP        0x80    /* use old (assembly) softfp package */
  562.  
  563. #ifdef _KERNEL
  564. /* Special delivery instructions for issig() and fsig() */
  565. #define SIG_ALLSIGNALS        0x0
  566. #define SIG_NOSTOPDEFAULT    0x1    /* Don't deliver stopdefault signals */
  567. #define SIG_NOPTRESCHED        0x2    /* Don't deliver SIGPTRESCHED. */
  568.  
  569. #define ISSIG(l, w)    (sigisready() && issig(l, w))
  570.  
  571. /*
  572.  * Flags to prlock() and procfind()
  573.  */
  574. #define    ZNO    0    /* Fail on encountering a zombie process. */
  575. #define    ZYES    1    /* Allow zombies. */
  576. #define EXECNO    0x02    /* fail on encountering an execing process */
  577.  
  578. extern struct proc    *proc;        /* the proc table itself */
  579.  
  580. /* fault trace variables */
  581. extern proc_t        *trproc;    /* process being traced */
  582. extern int        trflags;    /* trace flags */
  583.  
  584. #define    isresident(p)    (p)->p_resident
  585.  
  586. #if EXTUSIZE == 1
  587. /* Flags for stackext_alloc() */
  588. #define STACKEXT_NON_CRITICAL    0x1    /* Don't use the resvered space */
  589. #define STACKEXT_CRITICAL    0x2    /* Use the resvered space */
  590. #endif /* EXTUSIZE == 1 */
  591.  
  592. struct rusage;
  593. extern int newproc(int, uint);
  594. extern int procfork(int, uint, pid_t *, caddr_t *, size_t);
  595. extern struct user *uballoc(proc_t *, int);
  596. extern void ubfree(proc_t *, int);
  597. extern void setup_wired_tlb_notme(proc_t *);
  598. extern void setup_wired_tlb(proc_t *);
  599. #ifdef _HIBERNATORII
  600. extern int procnew(int, int, proc_t **, pid_t *);
  601. #else /* _HIBERNATORII */
  602. extern int procnew(int, int, proc_t **);
  603. #endif /* _HIBERNATORII */
  604. extern int procscan(int ((*)(proc_t *, void *, int)), void *);
  605. extern void *proccscan(proc_t *, void *((*)(proc_t *, void *)), void *);
  606. extern proc_t *procfind(pid_t, int);
  607. extern proc_t *proclock(proc_t *, int);
  608. extern void procunlock(proc_t *);
  609. extern void procfree(proc_t *);
  610. extern void procdeact(proc_t *);
  611. extern void procchain(proc_t *, proc_t *);
  612. extern void procunchain(proc_t *);
  613. extern int proc1chain(proc_t *);
  614. extern int inferior(proc_t *);
  615. extern int ancestor(proc_t *);
  616. extern void prochashtables(void);
  617. extern void recalcrss(proc_t *);
  618.  
  619. struct k_siginfo;
  620. struct sigqueue;
  621. union rval;
  622.  
  623. extern int wstat(int, int);
  624. extern void winfo(proc_t *, struct k_siginfo *, int);
  625. extern void signal(int, int);
  626. extern void psignal(proc_t *, int);
  627. extern void sigtoproc(struct proc *, int, int);
  628. extern void sigdeq(proc_t *, int, struct sigqueue **);
  629. extern int ksigqueue(struct proc *, int, int, const union sigval, int);
  630. extern int issig(int, uint);
  631. extern int isfatalsig(proc_t *);
  632. extern int sendsig(void (*hdlr)(), int, struct k_siginfo *, int);
  633. extern void hold_nonfatalsig(k_sigset_t *);
  634. extern void release_nonfatalsig(k_sigset_t *);
  635. extern void assign_ksigset(proc_t *, k_sigset_t *, k_sigset_t *);
  636. extern int psig(int);
  637. extern int checkstop(void);
  638. extern int wait_checkstop(proc_t *, int);
  639. extern void stop(proc_t *, ushort, ushort);
  640. extern int fsig(proc_t *, int);
  641. extern void freeproc(proc_t *, int, union rval *);
  642. extern int wait4(int *, int, struct rusage *, pid_t, union rval *);
  643. extern void setprun(proc_t *, int);
  644. extern void setrun(proc_t *);
  645. extern char chgrtpri(proc_t *, char);
  646. extern int chgpri(int, int);
  647. extern int resident(proc_t *);
  648. extern void nonresident(proc_t *);
  649. extern struct user *getub(proc_t *, struct user *);
  650. extern void forceinub(proc_t *);
  651. extern void checkfp(proc_t *, int);
  652. extern char *finduname(proc_t *);
  653. extern void pexit(void);
  654. extern void releasefd(void);
  655.  
  656. typedef void (*ecbfunc_t)(void*);
  657. extern int add_exit_callback(proc_t *, ecbfunc_t, void *);
  658.  
  659. #define SYNC_SIGNAL    1
  660. #define ASYNC_SIGNAL    2
  661.  
  662. /* context switch routines */
  663. extern void qswtch(int);
  664. extern void pswtch(int);
  665. extern void swtch(int);
  666. extern void presume(proc_t *, int);
  667. extern int save(k_machreg_t *);
  668. #if R4000 || R10000
  669. extern void resume(proc_t *, int, unsigned char);
  670. extern void resumekthread(proc_t *, int, unsigned char);
  671. #endif
  672. #if TFP
  673. extern void resume(proc_t *, int, unsigned char, unsigned char);
  674. extern void resumekthread(proc_t *, int, unsigned char, unsigned char);
  675. #endif
  676. extern void resumeidle(int);
  677. #if EXTUSIZE == 1
  678. extern uint stackext_alloc(int);
  679. extern void stackext_free(uint);
  680. extern int setup_stackext(proc_t *);
  681. #endif
  682. #endif
  683.  
  684. #if defined(_KERNEL) || defined(_KMEMUSER)
  685. /*
  686.  * shared group descriptor
  687.  * Each process that sproc()'s has one of these
  688.  *
  689.  * Locks/Semaphores:
  690.  *
  691.  *    s_listlock - also for modifying/accessing the list s_plink: use shared
  692.  *        shared lock for long term access, or use this for short term
  693.  *
  694.  *     s_detachsem - a mutex semaphore that serializes access to parts of
  695.  *        detachshaddr(). If a P() on this semaphore is successful,
  696.  *        then, guaranteed that no member of the share group may
  697.  *        remove detach regions of the address space.
  698.  */
  699.  
  700. typedef struct shaddr_s {
  701.     /* the following are all to handle VM */
  702.     preg_set_t     s_region;    /* processes' shared pregions */
  703.     pgno_t        s_totpregsize;    /* total size of shared regions. */
  704.     mrlock_t    s_aspacelock;    /* address space lock */
  705.     /* generic fields for handling share groups */
  706.     struct proc    *s_orig;    /* creater (or NULL) */
  707.     struct proc    *s_plink;    /* link to processes in share group */
  708.     struct pmap    *s_pmap;    /* page map pointer */
  709.     unsigned int    s_flag;        /* flags */
  710.     lock_t        s_listlock;    /* protects s_plink */
  711.     ushort        s_refcnt;    /* # process in list */
  712.     /* semaphore for single threading open directory updating */
  713.     short        s_fwaiting;    /* # waiting for inuse descriptors */
  714.     mutex_t        s_fupdsema;    /* wait for opening directory */
  715.     mrlock_t    s_fsync;    /* syncing file descriptors */
  716.     sema_t        s_fwait;    /* wait for inuse descriptors */
  717.     int        s_nofiles;    /* number of open files */
  718.     lock_t        s_fwaitlock;    /* protect s_fwaiting */
  719.     /* lock for updating misc things that don't need a semaphore */
  720.     lock_t        s_rupdlock;    /* update lock */
  721.     struct ufchunk    *s_flist;    /* open file descriptors and flags */
  722.     struct vnode    *s_cdir;    /* current directory */
  723.     struct vnode    *s_rdir;    /* root directory */
  724.     /* hold values for other sharing options */
  725.     unchar        s_sched;    /* scheduling mode of share gp */
  726.     short        s_cmask;    /* mask for file creation */
  727.     off_t        s_limit;    /* maximum write address */
  728.     cred_t        *s_cred;    /* shared ID's */
  729.     pgno_t        s_nlockpg;    /* # locked pages        */
  730.     /* share group scheduling information (protected by s_rupdlock) */
  731.     struct proc    *s_master;    /* proc that runs when in master mode */
  732.     mutex_t        s_brksema;    /* lock to serialize sbrk calls */
  733.     caddr_t        s_brkbase;    /* base addr of heap for brk/sbrk */
  734.     size_t        s_brksize;    /* size of heap */
  735.     caddr_t        s_lastspbase;    /* hint for stack allocation */
  736.     /* fields for isolated sproc support */
  737.     cpumask_t    s_isomask;    /* mask of isolated cpus in use */
  738.                     /* by share group */
  739.     /* mutex for single threading parts of detachshaddr() */
  740.     mutex_t        s_detachsem;
  741.     /* fields to manage pthread exit sequencing */
  742.     struct proc    *s_spid;    /* pthread leader */
  743.     sv_t        s_detached;    /* wait for last detach */
  744.     int        s_why;        /* exit status */
  745.     int        s_what;        /* exit status */
  746. #ifdef _VM_WS_SWAPPING
  747.     ws_proc_t    s_ws;        /* working set swapping variables */
  748. #endif
  749. #ifdef _SHAREII
  750.     struct kklnode_t *s_lnodeP;    /* Pointer to controlling lnode */
  751. #endif
  752.     lock_t        s_kobjlock;
  753.     kobj_t        *s_kobj[MAX_MODULES];
  754. } shaddr_t;
  755.  
  756.  
  757. /* shaddr_t s_flag values */
  758.  
  759. #define    SHDF_DATLOCK    0x0002        /* data space has been locked */
  760. #define    SHDF_SPIDEXIT    0x0004        /* spid group exitting */
  761.  
  762. #endif
  763.  
  764. #ifdef _KERNEL
  765. /* types for grabbing aspacelock */
  766. #define SH_ACC        MR_ACCESS
  767. #define SH_UPD        MR_UPDATE
  768.  
  769. #define IS_LCKUPD(p)        isaspacelock(p, SH_UPD)
  770. #define IS_LCKACC(p)        isaspacelock(p, SH_ACC)
  771. #define shdlock(p,t)        aspacelock(p,t)
  772. #define shdunlock(p)        aspaceunlock(p)
  773. #define cshdlock(p,t)        caspacelock(p,t)
  774.  
  775. /* lock and unlock shared directory descriptor updating */
  776. #define shddlock()    { if (curprocp->p_shaddr) sharedd_lock(); }
  777. #define shddunlock()    { if (curprocp->p_shaddr) sharedd_unlock(); }
  778. #define IS_DLCK(p)    (mutex_owner(&(p)->p_shaddr->s_fupdsema) == curprocp)
  779. #define ISSHDFD(p, sa)    (sa && (((p)->p_shmask & PR_SFDS) != 0))
  780.  
  781. /* flags for detachshaddr */
  782. #define SHDEXEC        0x0001    /* process is execing */
  783. #define SHDEXIT        0x0002    /* process is exitting */
  784.  
  785. struct user;
  786. extern int allocshaddr(proc_t *, uint);
  787. extern void attachshaddr(proc_t *, proc_t *);
  788. extern void detachshaddr(int, int *, int *);
  789. extern void sharedd_lock(void);
  790. extern void sharedd_unlock(void);
  791. extern void setshdsync(shaddr_t *, int, int);
  792. extern void dosync(int);
  793. extern void aspacelock(proc_t *, int);
  794. extern int caspacelock(proc_t *, int);
  795. extern void aspaceunlock(proc_t *);
  796. extern int isaspacelock(proc_t *, int);
  797. #endif
  798.  
  799. #if defined(_KERNEL) || defined(_KMEMUSER)
  800. typedef struct pgroup_s {
  801.         pid_t       pg_pgrp;        /* name of process group leader */
  802.     ushort        pg_flag;    /* process group status */
  803.     ushort        pg_refcnt;    /* count of process group */
  804.     struct proc    *pg_chain;    /* process group chain */
  805.     struct pgroup_s *pg_next;    /* hash chain */
  806. } pgroup_t;
  807.  
  808. #define    PGORPHANED    0x0001        /* this process detached from ctty */
  809. #define PGINUSE        0x0002        /* this process group was sent signal*/
  810.  
  811. #endif  /* _KERNEL || _KMEMUSER */
  812.  
  813. /* session stuff now contained in "session.h" */
  814.  
  815. #ifdef _KERNEL
  816.  
  817. typedef struct uidinfo_s {
  818.     struct uidinfo_s *ui_next;    /* uidinfo hash chain */
  819.     struct uidinfo_s *ui_prev;    /* uidinfo hash chain */
  820.     uid_t        ui_uid;        /* uid of uid we're keeping track of */
  821.     int        ui_cnt;        /* count of procs with this uid */
  822. } uidinfo_t;
  823.  
  824. extern void dropuidinforef(uidinfo_t *);
  825. extern uidinfo_t *takeuidref(uid_t);
  826.  
  827. #define changeuidinfo() \
  828.     if (curprocp->p_cred->cr_ruid != curprocp->p_uidinfo->ui_uid) { \
  829.         dropuidinforef(curprocp->p_uidinfo); \
  830.         curprocp->p_uidinfo = takeuidref(curprocp->p_cred->cr_ruid); \
  831.     } \
  832.  
  833. enum jobcontrol {
  834.         JCTLREAD,                     /* read data on a ctty */
  835.         JCTLWRITE,                     /* write data to a ctty */
  836.         JCTLGST                         /* get ctty parameters */
  837. };
  838.  
  839. extern mutex_t    pglobal;        /* global process group mutex */
  840. extern lock_t    pgchainlck;        /* global process chain lock */
  841.  
  842. struct vnode;
  843. typedef int (*pgrpscanfunc_t)(proc_t *, long);
  844. extern int pgrpscan(pid_t, pgrpscanfunc_t, long);
  845. extern void detachildren(proc_t *);
  846. extern void joinpg(proc_t *, pid_t, int);
  847. extern void leavepg(proc_t *, int);
  848. extern pgroup_t *findpg(pid_t);
  849. extern int pgrpverify(proc_t *, pid_t);
  850. extern int memberspg(proc_t *, pid_t);
  851.  
  852. typedef unsigned char tlbpid_t;
  853. typedef unsigned char icachepid_t;
  854.  
  855. /* process tlb routines */
  856. extern void new_tlbpid(proc_t *, int);
  857. #if TFP
  858. extern void new_icachepid(proc_t *, int);
  859. extern void icacheinfo_init(void);
  860. extern int icachepid_is_usable(proc_t *);
  861. extern void icachepid_use(proc_t *, tlbpid_t);
  862. #endif
  863. extern void newptes(proc_t *, caddr_t, uint, uint);
  864. extern int tlbsync(proc_t *, int);
  865. extern void tlbdirty(proc_t *);
  866. extern void tlbclean(proc_t *, __psunsigned_t, cpumask_t);
  867. extern void set_tlbpids(proc_t *, unsigned char);
  868. extern void tlbinfo_init(void);
  869. extern int tlbpid_is_usable(proc_t *);
  870. extern void tlbpid_use(proc_t *, tlbpid_t);
  871. extern void tlb_onesec_actions(void);
  872. extern void tlb_tick_actions(void);
  873. #ifdef ULI
  874. tlbpid_t alloc_private_tlbpid(struct proc *);
  875. void free_private_tlbpid(tlbpid_t);
  876. #ifdef TFP
  877. icachepid_t alloc_private_icachepid(struct proc *);
  878. void free_private_icachepid(icachepid_t);
  879. #endif
  880. #endif
  881.  
  882. struct cred;
  883. extern int hasprocperm(proc_t *, struct cred *);
  884.  
  885. #endif /* _KERNEL */
  886.  
  887. #if defined(_KERNEL) || defined(_KMEMUSER)
  888. #include <sys/signal.h>            /* for NUMSIGS */
  889. typedef struct sigvec_s {
  890.     uint        sv_flags;    /* SNOCLDSTOP, SNOWAIT and lock */
  891.     uint        sv_refcnt;    /* reference count */
  892.     k_sigset_t    sv_sig;        /* set of pending async signals */
  893.     void        (*sv_hndlr[NUMSIGS])();    /* signal dispositions */
  894.     k_sigset_t    sv_sigmasks[NUMSIGS];    /* mask during handlers */
  895.     k_sigset_t    sv_sigign;    /* signals to be ignored */
  896.     k_sigset_t    sv_sigcatch;    /* signals to be caught */
  897.     k_sigset_t    sv_sigrestart;    /* signals to restart sys calls */
  898.     k_sigset_t    sv_signodefer;    /* signals deferred when caught */
  899.     k_sigset_t    sv_sigresethand;/* signals reset when caught */
  900.     k_sigset_t    sv_sainfo;    /* signals delivered w/ siginfo */
  901.     struct sigqueue    *sv_sigqueue;    /* queued siginfo structures */
  902.     struct sigqueue    *sv_sigqfree;    /* free list of siginfo structures */
  903. } sigvec_t;
  904.  
  905. /* Flags for sv_flags */
  906.  
  907. #define SIGVEC_LOCK    0x00000001    /* Bit used for structure lock */
  908. #define SNOCLDSTOP    0x00000002    /* SIGCHLD not sent when child stops */
  909. #define SNOWAIT        0x00000004    /* children never become zombies */
  910.  
  911. #define sigvec_lock(sv)        mutex_bitlock(&(sv)->sv_flags, SIGVEC_LOCK)
  912. #define sigvec_unlock(sv, rv)    mutex_bitunlock(&(sv)->sv_flags,SIGVEC_LOCK,rv)
  913. #define sigvec_is_locked(sv)     bitlock_islocked(&(sv)->sv_flags, SIGVEC_LOCK)
  914. #define nested_sigvec_lock(sv)    nested_bitlock(&(sv)->sv_flags, SIGVEC_LOCK)
  915. #define nested_sigvec_unlock(sv) nested_bitunlock(&(sv)->sv_flags, SIGVEC_LOCK)
  916. #endif /* _KERNEL || _KMEMUSER */
  917.  
  918. #endif /* __SYS_PROC_H__ */
  919.